// 引入API工具
const { loginAPI } = require('../../utils/api.js');
const { loginDebug } = require('../../utils/debug.js');

Page({
  data: {
    wechatLoading: false,
    authStep: 'initial', // initial, authorizing, success, failed
    userInfo: null,
    loginProgress: 0,
    lastCodeTime: 0, // 记录上次获取code的时间
    lastCode: null // 记录上次使用的code
  },

  onLoad: function (options) {
    // 页面加载时检查是否已登录
    this.checkLoginStatus();
  },

  // 检查登录状态
  checkLoginStatus: function() {
    const isLoggedIn = wx.getStorageSync('isLoggedIn');
    if (isLoggedIn) {
      // 如果已登录，直接跳转到首页
      wx.redirectTo({
        url: '/pages/index/index'
      });
    }
  },

  // 微信授权登录
  handleWechatLogin: function() {
    if (this.data.wechatLoading) return;
    
    // 防止频繁调用 - 5秒内不允许重复调用
    const now = Date.now();
    if (now - this.data.lastCodeTime < 5000) {
      console.warn('登录调用过于频繁，请稍后再试');
      wx.showToast({
        title: '请勿频繁登录',
        icon: 'none'
      });
      return;
    }
    
    // 开始登录调试
    loginDebug.logLoginStart();
    
    this.setData({
      wechatLoading: true,
      authStep: 'authorizing',
      loginProgress: 0,
      lastCodeTime: now
    });

    // 使用Promise.all同时执行wx.login和wx.getUserProfile
    const loginPromise = new Promise((resolve, reject) => {
      wx.login({
        success: (res) => {
          loginDebug.logWxLoginResult(res);
          if (res.code) {
            // 检查code是否重复
            if (res.code === this.data.lastCode) {
              console.warn('检测到重复的code，可能存在缓存问题');
              loginDebug.logLoginError('重复code检测', `重复code: ${res.code}`);
              reject(new Error('重复code'));
              return;
            }
            console.log('微信登录成功，获取到真实code:', res.code);
            resolve(res);
          } else {
            console.error('微信登录失败，未获取到code');
            loginDebug.logLoginError('微信登录失败', '未获取到code');
            reject(new Error('未获取到code'));
          }
        },
        fail: (error) => {
          console.error('微信登录API调用失败:', error);
          loginDebug.logLoginError(error, '微信登录API调用失败');
          reject(error);
        }
      });
    });

    const userProfilePromise = new Promise((resolve, reject) => {
      wx.getUserProfile({
        desc: '用于完善用户资料',
        success: (res) => {
          console.log('获取用户信息成功:', res.userInfo);
          resolve(res);
        },
        fail: (error) => {
          console.error('获取用户信息失败:', error);
          loginDebug.logLoginError(error, '获取用户信息失败');
          reject(error);
        }
      });
    });

    // 同时执行登录和获取用户信息
    Promise.all([loginPromise, userProfilePromise])
      .then((results) => {
        const [loginRes, userProfileRes] = results;
        
        // 记录当前code
        this.setData({
          lastCode: loginRes.code,
          loginProgress: 60
        });
        
        // 调用后端登录接口
        const { nickName, avatarUrl } = userProfileRes.userInfo;
        this.callLoginAPI(loginRes.code, nickName, avatarUrl);
      })
      .catch((error) => {
        console.error('登录过程失败:', error);
        if (error.message === '重复code') {
          // 等待1秒后重试
          setTimeout(() => {
            this.retryLogin();
          }, 1000);
        } else {
          this.handleWechatLoginFail('登录授权失败');
        }
      });
  },

  // 重试登录
  retryLogin: function() {
    console.log('重试获取微信登录code');
    wx.login({
      success: (res) => {
        if (res.code && res.code !== this.data.lastCode) {
          console.log('重试成功，获取到新的code:', res.code);
          this.setData({
            lastCode: res.code
          });
          this.getUserProfile(res.code);
        } else {
          console.error('重试仍然获取到重复或无效的code');
          this.handleWechatLoginFail('获取授权码失败，请稍后重试');
        }
      },
      fail: (error) => {
        console.error('重试登录失败:', error);
        this.handleWechatLoginFail('登录重试失败');
      }
    });
  },

  // 模拟登录（开发环境使用）- 已移除，始终使用真实code
  // simulateLogin: function() {
  //   // 此方法已被移除，现在始终使用真实的微信授权code
  // },

  // 获取用户信息 - 此方法已不再使用，因为现在在handleWechatLogin中同时处理
  // getUserProfile: function(code) {
  //   // 此方法已被整合到handleWechatLogin中
  // },

  // 调用后端登录API
  callLoginAPI: function(code, nickname, avatarUrl) {
    console.log('开始调用后端登录API:', { code, nickname, avatarUrl });
    
    // 验证code的基本格式
    if (!code || code.length < 10) {
      console.error('无效的授权码格式:', code);
      loginDebug.logLoginError('无效授权码', code);
      this.handleWechatLoginFail('授权码格式错误');
      return;
    }
    
    // 检查是否为已使用的code
    const usedCodes = wx.getStorageSync('usedCodes') || [];
    if (usedCodes.includes(code)) {
      console.error('检测到已使用的授权码:', code);
      loginDebug.logLoginError('重复使用授权码', code);
      this.handleWechatLoginFail('授权码已被使用，请重新登录');
      return;
    }
    
    loginDebug.logApiCall({ code, nickname, avatarUrl });
    
    this.setData({
      loginProgress: 80
    });

    // 记录code为已使用（临时存储5分钟）
    usedCodes.push(code);
    // 只保留最近10个code记录，避免存储过多
    if (usedCodes.length > 10) {
      usedCodes.shift();
    }
    wx.setStorageSync('usedCodes', usedCodes);
    
    // 5分钟后清理已使用的code记录
    setTimeout(() => {
      const currentUsedCodes = wx.getStorageSync('usedCodes') || [];
      const index = currentUsedCodes.indexOf(code);
      if (index > -1) {
        currentUsedCodes.splice(index, 1);
        wx.setStorageSync('usedCodes', currentUsedCodes);
      }
    }, 5 * 60 * 1000); // 5分钟

    // 显示加载提示
    wx.showLoading({
      title: '登录中...',
      mask: true
    });

    // 调用后端API
    loginAPI.wechatLogin(code, nickname, avatarUrl)
      .then(response => {
        console.log('后端API调用成功:', response);
        loginDebug.logApiResponse(response);
        
        wx.hideLoading();
        
        this.setData({
          loginProgress: 100
        });

        // 检查响应格式
        if (response && response.code === 200 && response.data) {
          const userInfo = response.data;
          
          // 保存用户信息到本地存储
          wx.setStorageSync('userInfo', userInfo);
          wx.setStorageSync('isLoggedIn', true);
          wx.setStorageSync('token', userInfo.token);
          wx.setStorageSync('openid', userInfo.openid);
          
          // 显示登录成功
          this.handleWechatLoginSuccess(userInfo);
        } else {
          console.error('API响应格式错误:', response);
          loginDebug.logLoginError(response, 'API响应格式错误');
          this.handleWechatLoginFail(response?.message || response?.msg || '登录失败，请重试');
        }
      })
      .catch(error => {
        console.error('后端API调用失败:', error);
        loginDebug.logLoginError(error, '后端API调用失败');
        
        wx.hideLoading();
        
        let errorMessage = '网络连接异常，请检查网络后重试';
        
        // 根据错误类型提供更具体的错误信息
        if (error.code === -1) {
          // 网络请求失败
          errorMessage = '网络连接失败，请检查网络设置后重试';
        } else if (error.code === 500) {
          // 服务器错误或模拟登录失败
          errorMessage = error.message || '登录失败，请重试';
        } else if (error.message) {
          if (error.message.includes('timeout')) {
            errorMessage = '请求超时，请检查网络连接';
          } else if (error.message.includes('network')) {
            errorMessage = '网络连接失败，请检查网络设置';
          } else if (error.message.includes('500')) {
            errorMessage = '服务器内部错误，请稍后重试';
          } else if (error.message.includes('404')) {
            errorMessage = '服务接口不存在，请联系管理员';
          } else if (error.message.includes('40163') || error.message.includes('code been used')) {
            errorMessage = '授权码已被使用，请重新登录';
            // 清理本地code记录
            this.setData({
              lastCode: null
            });
          } else if (error.message.includes('模拟登录失败')) {
            errorMessage = '登录失败，请重试（开发模式）';
          } else {
            errorMessage = error.message;
          }
        }
        
        // 显示错误提示
        wx.showToast({
          title: errorMessage,
          icon: 'none',
          duration: 3000
        });
        
        this.handleWechatLoginFail(errorMessage);
      });
  },

  // 处理授权取消
  handleAuthCancel: function() {
    this.setData({
      wechatLoading: false,
      authStep: 'initial',
      loginProgress: 0
    });

    wx.showToast({
      title: '已取消授权',
      icon: 'none',
      duration: 2000
    });
  },

  // 处理微信登录成功
  handleWechatLoginSuccess: function(userInfo) {
    wx.hideLoading();
    
    this.setData({
      authStep: 'success',
      wechatLoading: false
    });

    // 显示欢迎信息
    wx.showModal({
      title: '登录成功',
      content: `欢迎您，${userInfo.nickName}！\n来自：${userInfo.province} ${userInfo.city}`,
      showCancel: false,
      confirmText: '开始学习',
      success: () => {
        // 保存登录状态和用户信息
        wx.setStorageSync('isLoggedIn', true);
        wx.setStorageSync('loginType', 'wechat');
        wx.setStorageSync('userInfo', userInfo);

        // 跳转到首页
        wx.redirectTo({
          url: '/pages/index/index'
        });
      }
    });
  },

  // 处理微信登录失败
  handleWechatLoginFail: function(message) {
    wx.hideLoading();
    
    this.setData({
      wechatLoading: false,
      authStep: 'failed',
      loginProgress: 0
    });

    wx.showModal({
      title: '登录失败',
      content: message || '网络连接异常，请检查网络后重试',
      showCancel: true,
      cancelText: '取消',
      confirmText: '重试',
      success: (res) => {
        if (res.confirm) {
          // 用户选择重试
          setTimeout(() => {
            this.handleWechatLogin();
          }, 500);
        } else {
          // 重置状态
          this.setData({
            authStep: 'initial'
          });
        }
      }
    });
  },

  // 快速登录（开发测试用）
  quickLogin: function() {
    // 使用测试账号直接调用后端API
    this.callLoginAPI('test_code_123', '测试用户', '/images/avatar.png');
  }
});